home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / jck1.arc / JCK1.ASM next >
Assembly Source File  |  1985-09-23  |  12KB  |  283 lines
  1. KB_SEG  SEGMENT AT 40H                  ;ROM BIOS data area
  2.         ORG     1AH                     ;Location of keyboard buffer
  3. KB_HEAD DW      ?                       ;Buffer head
  4. KB_TAIL DW      ?                       ;Buffer tail.
  5. KB_BUFFER DW    16 DUP (?)              ;Actual keyboard buffer
  6. KB_BUFFER_END LABEL WORD                ;Two bytes past end of buffer
  7. KB_SEG  ENDS
  8.  
  9. CODE_SEG SEGMENT
  10.  
  11.         TRUE    = 1                     ;Pseudo-Ops
  12.         FALSE   = 0
  13.  
  14.         ASSUME  CS:CODE_SEG
  15.         ORG     100H                    ;A Com file
  16.  
  17. BEGIN:  JMP     INITIALIZE              ;Skip data and Interrupt routine
  18.  
  19. COPYRIGHT        DB      'Author Mark Boatright; Copyright 1985'
  20.  
  21. TST_FLG DB ?
  22.  
  23.         COMMAND_KEYS DW 5400H           ;SHIFT F1 300,7,E,1
  24.         DW      5500H                   ;SHIFT F2 300,8,N,1
  25.         DW      5600H                   ;SHIFT F3 1200,7,E,1
  26.         DW      5700H                   ;SHIFT F4 1200,8,N,1
  27.         DW      5800H                   ;SHIFT F5 2400,7,N,1
  28.         DW      5900H                   ;SHIFT F6 2400,8,N,1
  29.  
  30. ;DATA_8250A stored in this format LSB, MSB, and a byte for parity,length and
  31. ;stopbit
  32.  
  33.         DATA_8250A DB 75H,01H,1AH       ;300,E,7,1
  34.         DB      75H,01H,07H             ;300,N,8,1
  35.         DB      5DH,00H,1AH             ;1200,E,7,1
  36.         DB      5DH,00H,07H             ;1200,N,8,1
  37.         DB      2FH,00H,1AH             ;2400,E,7,1
  38.         DB      2FH,00H,07H             ;2400,N,8,1
  39.  
  40. MESSAGE DB         'JR Communications Kludge installed.  (C) 1985 by '
  41.         DB         'Mark Boatright'
  42.         DB 0DH,0AH,'(For built in serial port, will not address internal '
  43.         DB         'modem.)'
  44.         DB 0DH,0AH
  45.         DB 0DH,0AH,'                COMMANDS'
  46.         DB 0DH,0AH
  47.         DB 0DH,0AH,'SHIFT F1  300,E,7,1  SHIFT F2  300,N,8,1'
  48.         DB 0DH,0AH,'SHIFT F3 1200,E,7,1  SHIFT F4 1200,N,8,1'
  49.         DB 0DH,0AH,'SHIFT F5 2400,E,7,1  SHIFT F6 2400,N,8,1'
  50.         DB 0DH,0AH
  51.         DB 0DH,0AH,'              INSTRUCTIONS'
  52.         DB 0DH,0AH
  53.         DB 0DH,0AH,'1. Load Communications Program.'
  54.         DB 0DH,0AH,'2. Use one of the kludge commands to set your comm parms.'
  55.         DB 0DH,0AH
  56.         DB 0DH,0AH,'NOTE: You may need to set comm parms with the '
  57.         DB         'communications program first, '
  58.         DB 0DH,0AH,'      then use kludge.'
  59.         DB 0DH,0AH
  60.         DB 0DH,0AH,'NOTE: A few programs (most do not) address built in port '
  61.         DB         'as COM2.'
  62.         DB 0DH,0AH,'      In that event adjust program defalts accordingly'
  63.         DB 0DH,0AH
  64.         DB 0DH,0AH,'NOTE: This version of kludge will not help with dialing '
  65.         DB         'directory problems.'
  66.         DB 0DH,0AH,'      Dial from keyboard.'
  67.         DB 0DH,0AH
  68.         DB 0DH,0AH,'EXPERIMENT.  GOOD LUCK!!'
  69.         DB 0H
  70.  
  71.  
  72. ROM_KB_INT_9 DD 1                       ;Should be location of ROM INT 9
  73.                                         ;routine
  74.  
  75. RESIDENT_MAINLINE PROC NEAR             ;OK, someone's pressed a key.
  76.         PUSH    DS                      ;Save what we use
  77.         PUSH    SI
  78.         PUSH    DX
  79.         PUSH    CX
  80.         PUSH    BX
  81.         PUSH    AX
  82.         PUSHF                           ;For ROM_KB_INT_9 IRET
  83.                                         ;IRET will pop them off stack.
  84.         CALL    ROM_KB_INT_9            ;Put the key in buffer
  85.  
  86.         ASSUME  DS:KB_SEG               ;We need data from this segment
  87.         MOV     AX,KB_SEG
  88.         MOV     DS,AX
  89.  
  90.  
  91.         CALL    FIND_CHAR               ;find char in buffer, if any
  92.         CMP     TST_FLG,TRUE            ;if char valid TST_FLG returns true
  93.         JNE     EXIT_MAINLINE           ;Not true, we leave
  94.         CALL    KEY_CHECK               ;Is the character a command key?
  95.         CMP     TST_FLG,TRUE            ;Result of check in TST_FLG
  96.         JNE     EXIT_MAINLINE           ;If not a command then exit
  97.         CLI                             ;Shucks, JR keyboard is NMI, oh well
  98.         CALL    LOOK_UP                 ;Where's the data for the command?
  99.         CALL    BYTES_OUT               ;Reset 8250A to proper JR parms
  100.  
  101.  
  102.  
  103. EXIT_MAINLINE:
  104.  
  105.         POP     AX                      ;restore registers
  106.         POP     BX
  107.         POP     CX
  108.         POP     DX
  109.         POP     SI
  110.         POP     DS
  111.         STI
  112.         IRET                            ;return for terminate but stay resident
  113.  
  114. RESIDENT_MAINLINE ENDP
  115.  
  116. FIND_CHAR PROC  NEAR
  117. ;On exit BX should point to character
  118.  
  119.         MOV     TST_FLG,FALSE
  120.         MOV     BX,KB_TAIL
  121.         CMP     BX,KB_HEAD              ;HEAD=TAIL then no valid character
  122.         JNE     VALID_CHAR
  123.         RET                             ;and we return with TST_FLG=FALSE
  124. VALID_CHAR:
  125.         MOV     TST_FLG,TRUE            ;We know we've got a character
  126.         SUB     BX,2                    ;Try and move back a couple of bytes
  127.                                         ;from kb_tail, if we're still in the
  128.                                         ;buffer this will be location of char.
  129.         CMP     BX,OFFSET KB_BUFFER     ;Are we still in the buffer?
  130.         JB      WRAP                    ;No, we'd better wrap
  131.         RET                             ;We're OK, let's go back
  132. WRAP:
  133.         MOV     BX,OFFSET KB_BUFFER_END ;Wrap around the buffer queue
  134.         SUB     BX,2
  135.         RET                             ;We're OK now, let's return
  136. FIND_CHAR ENDP
  137.  
  138. KEY_CHECK PROC  NEAR
  139. ;On entry BX points to character in buffer.
  140. ;On exit TST_FLG returns status of check (true/false).
  141. ;If TST_FLG true, then CX contains the number of the command.
  142.  
  143.         MOV     TST_FLG,FALSE           ;Assume char not a command key
  144.         MOV     AX,[BX]                 ;Put the character in AX
  145.         LEA     SI,COMMAND_KEYS         ;Put starting address in SI
  146.         MOV     CX,6                    ;Put no. of command keys in CX
  147.  
  148. CHECK:
  149.         CMP     AX,CS:[SI]              ;Is char a command key?
  150.         JE      MATCH                   ;Yes, jump out.
  151.         ADD     SI,2                    ;Address of next command key
  152.         LOOP    CHECK                   ;Do it again
  153.         RET                             ;No Match found.
  154. MATCH:                                  ;OK, we've got a match.
  155.         MOV     TST_FLG,TRUE            ;So Resident_Mainline knows we found
  156.                                         ;match
  157.         MOV     KB_TAIL,BX              ;Since it's a command key we'll take
  158.                                         ;this character out of buffer
  159.  
  160.         NEG     CX                      ;This gives us relative positioh
  161.         ADD     CX,6                    ;of command key... in CX.
  162.         RET
  163.  
  164. KEY_CHECK ENDP
  165.  
  166. LOOK_UP PROC    NEAR
  167. ;On entry CX contains no.(relative to position) of command
  168. ;On exit SI has starting address of relevant 8250A data
  169.  
  170.         MOV     AX,CX                   ;Put no. of command in AX
  171.         MOV     CX,3                    ;And multiply it by number of
  172.         MUL     CL                      ;bytes in 8250A_DATA/no. of
  173.                                         ;command keys. This = 3.
  174.         LEA     SI,DATA_8250A           ;Starting address in SI
  175.         ADD     SI,AX                   ;Starting address of data we want
  176.         RET                             ;We've got our address
  177. LOOK_UP ENDP
  178.  
  179. BYTES_OUT PROC  NEAR
  180. ;For better understanding of what this routine does see the JR Tech Ref
  181. ;section on the serial port.
  182. ;On entry SI should contain the starting adress of data (DATA_8250A).
  183. ;Data arranged in this format
  184. ;1. a byte for MSB of baud rate divisor
  185. ;2. a byte for LSB of baud rate divisor
  186. ;3. a byte to set other comm parms--stopbit, wordlength, parity
  187.  
  188.         MOV     DX,2FBH                 ;Line Control register address
  189.         MOV     AL,10000000B            ;Must set DLAB (Divisor Latch Address
  190.                                         ;Byte) high. Bit 7 = 1.
  191.         OUT     DX,AL                   ;to access divisor latches LSB and MSB
  192.         JMP     SHORT KT1               ;As per JR Tech Ref... We stick in
  193.                                         ;these jumps to avoid back to back
  194.                                         ;I/0 operations to 8250A and accomodate
  195.                                         ;the 8250A read/write cycle time.
  196. KT1:    MOV     DX,2F8H                 ;Address baud rate divisor LSB
  197.         MOV     AX,CS:[SI]              ;The LSB
  198.         OUT     DX,AL
  199.         JMP     SHORT KT2               ;Kill time.
  200. KT2:    INC     SI                      ;To next byte of data
  201.         MOV     DX,2F9H                 ;Address baud rate divisor, MSB
  202.         MOV     AX,CS:[SI]              ;The MSB
  203.         OUT     DX,AL
  204.         JMP     SHORT KT3               ;Kill time.
  205. KT3:    INC     SI                      ;To next byte of data
  206.         MOV     DX,2FBH                 ;Address line control register
  207.         MOV     AX,CS:[SI]              ;The other Comm parms
  208.         OUT     DX,AL                   ;DLAB should now be low again.
  209.         JMP     SHORT KT4               ;Kill time.
  210. KT4:    MOV     DX,2F8H                 ;As per JR Tech Ref, writing to
  211.                                         ;line control register may have
  212.         IN      AL,DX                   ;caused data ready to go high
  213.  
  214.         RET                             ;don't want to forget this
  215.  
  216. BYTES_OUT ENDP
  217.  
  218. INITIALIZE PROC NEAR
  219.         CALL    GET_VECTOR
  220.         CALL    INSTALL_VECTOR
  221.         CALL    CLEAR_BUFFER
  222.         CALL    MESSAGE_OUT
  223.  
  224.         MOV     DX,OFFSET INITIALIZE    ;for terminate/stay resident
  225.         INT     27H                     ;Terminate/stay resident
  226. INITIALIZE ENDP
  227.  
  228. GET_VECTOR PROC NEAR
  229. ;We'll use DOS function 35H, vector received in ES:BX pair
  230.  
  231.         MOV     AL,9H                   ;we want vector for interrupt 9
  232.         MOV     AH,35H                  ;For DOS get interrupt vector function
  233.         INT     21H                     ;invoke the function
  234.         MOV     WORD PTR ROM_KB_INT_9,BX
  235.         MOV     WORD PTR ROM_KB_INT_9[2],ES
  236.         RET
  237.  
  238. GET_VECTOR ENDP
  239.  
  240. INSTALL_VECTOR PROC NEAR
  241.  
  242.         ASSUME  DS:CODE_SEG             ;for function 25H
  243.         PUSH    CS                      ;We send out vector we want
  244.         POP     DS                      ;to install in DS:DX pair
  245.         MOV     DX, OFFSET RESIDENT_MAINLINE
  246.         CLI
  247.         MOV     AH,25H                  ;Use DOS function 25H to make
  248.         MOV     AL,9H                   ;INT 9 vector point to our
  249.         INT     21H                     ;routine.
  250.         STI
  251.         RET
  252. INSTALL_VECTOR ENDP
  253.  
  254. CLEAR_BUFFER PROC NEAR                  ;clears the keyboard buffer
  255.         ASSUME  DS:KB_SEG
  256.         MOV     AX,KB_SEG
  257.         MOV     DS,AX
  258.         MOV     BX,OFFSET KB_BUFFER     ;Head and Tail set equal to
  259.         MOV     KB_HEAD,BX              ;first byte of buffer.
  260.         MOV     KB_TAIL,BX              ;Head = Tail so buffer cleared
  261.         RET
  262. CLEAR_BUFFER ENDP
  263.  
  264. MESSAGE_OUT PROC NEAR
  265.         ASSUME DS:CODE_SEG
  266.         PUSH CS
  267.         POP  DS
  268.         LEA     SI,MESSAGE
  269.         MOV     AH,2                    ;For Dos Standard Output function
  270. MESS_OUT:
  271.         MOV     DL,[SI]                 ;Get a byte
  272.         CMP     DL,0                    ;Done?
  273.         JE      MESS_OUT_DONE           ;YES, jump out of loop.
  274.         INT     21H                     ;No, send out the byte
  275.         INC     SI                      ;Point SI at next byte
  276.         JMP     MESS_OUT                ;Do it again
  277. MESS_OUT_DONE:
  278.         RET
  279. MESSAGE_OUT ENDP
  280.  
  281. CODE_SEG ENDS
  282.         END     BEGIN                   ;Tell Dos where to start when it
  283.                                         ;loads program.